Incommensurable design descriptions

Data management is a persistent problem in design and manufacturing. This is because different processes require different descriptions of the same design concept. Descriptions can include geometry and/or topology as well as other non-spatial information, such as design intent, and over the course of a design and manufacturing process it is often necessary to convert between descriptions non-sequentially, to support development and realisation of a design concept. This paper highlights the difficulties that arise in managing different descriptions by exploring what are possibly unrealistically simple examples involving drawings of simple shapes. Although simple, the examples illustrate a fundamental truth; that the information embedded in the structures of different descriptions of a design are often incommensurable, and this can introduce challenges in the management of design data

References to past designs

Designing by adaptation is almost invariably a dominantambiguity feature of designing, and references to past designs are ubiquitous in design discourse. Object references serve as indices into designers' stocks of design concepts, in which memories for concrete embodiments and exemplars are tightly bound to solution principles. Thinking and talking by reference to past designs serves as a way to reduce the overwhelming complexity of complex design tasks by enabling designers to use parsimonious mental representations to which details can be added as needed. However object references can be ambiguous, and import more of the past design than is intended or may be desirable

Ambiguity is a double-edged sword: similarity references in communication

Designers often explain new concepts and new ideas by reference to existing designs. This is parsimonious, as it only requires a pointer to the referent and a description of the modifications. Such descriptions can be extremely powerful, expressing the entire context of a design or a process in a few words. However similarity assertions are inherently ambiguous, because they depend not only on the chosen description but also on the intention behind the similarity comparison. In this paper we attempt to analyse the effect that the ambiguity of similarity references has on communication and idea generation in design. The reinterpretation of a similarity assertion can be extremely creative, where ambiguity allows for new interpretations of a problem. At the same time, it can make accurate communication extremely difficult because every assertion can be interpreted differently unless the context is fully shared

Pushdown Control-Flow Analysis of Higher-Order Programs

Context-free approaches to static analysis gain precision over classical approaches by perfectly matching returns to call sites---a property that eliminates spurious interprocedural paths. Vardoulakis and Shivers's recent formulation of CFA2 showed that it is possible (if expensive) to apply context-free methods to higher-order languages and gain the same boost in precision achieved over first-order programs. To this young body of work on context-free analysis of higher-order programs, we contribute a pushdown control-flow analysis framework, which we derive as an abstract interpretation of a CESK machine with an unbounded stack. One instantiation of this framework marks the first polyvariant pushdown analysis of higher-order programs; another marks the first polynomial-time analysis. In the end, we arrive at a framework for control-flow analysis that can efficiently compute pushdown generalizations of classical control-flow analyses.Comment: The 2010 Workshop on Scheme and Functional Programmin

Doctor of Philosophy

dissertationIn the static analysis of functional programs, control- ow analysis (k-CFA) is a classic method of approximating program behavior as a infinite state automata. CFA2 and abstract garbage collection are two recent, yet orthogonal improvements, on k-CFA. CFA2 approximates program behavior as a pushdown system, using summarization for the stack. CFA2 can accurately approximate arbitrarily-deep recursive function calls, whereas k-CFA cannot. Abstract garbage collection removes unreachable values from the store/heap. If unreachable values are not removed from a static analysis, they can become reachable again, which pollutes the final analysis and makes it less precise. Unfortunately, as these two techniques were originally formulated, they are incompatible. CFA2's summarization technique for managing the stack obscures the stack such that abstract garbage collection is unable to examine the stack for reachable values. This dissertation presents introspective pushdown control-flow analysis, which manages the stack explicitly through stack changes (pushes and pops). Because this analysis is able to examine the stack by how it has changed, abstract garbage collection is able to examine the stack for reachable values. Thus, introspective pushdown control-flow analysis merges successfully the benefits of CFA2 and abstract garbage collection to create a more precise static analysis. Additionally, the high-performance computing community has viewed functional programming techniques and tools as lacking the efficiency necessary for their applications. Nebo is a declarative domain-specific language embedded in C++ for discretizing partial differential equations for transport phenomena. For efficient execution, Nebo exploits a version of expression templates, based on the C++ template system, which is a type-less, completely-pure, Turing-complete functional language with burdensome syntax. Nebo's declarative syntax supports functional tools, such as point-wise lifting of complex expressions and functional composition of stencil operators. Nebo's primary abstraction is mathematical assignment, which separates what a calculation does from how that calculation is executed. Currently Nebo supports single-core execution, multicore (thread-based) parallel execution, and GPU execution. With single-core execution, Nebo performs on par with the loops and code that it replaces in Wasatch, a pre-existing high-performance simulation project. With multicore (thread-based) execution, Nebo can linearly scale (with roughly 90% efficiency) up to 6 processors, compared to its single-core execution. Moreover, Nebo's GPU execution can be up to 37x faster than its single-core execution. Finally, Wasatch (the pre-existing high-performance simulation project which uses Nebo) can scale up to 262K cores

Towards product platform introduction: optimising commonality of components

Companies that design and manufacture products for a wide range of related applications need to offer the right product for each use. A platform design strategy allows designing the product range based on product platforms, where some of the components and systems are common across the range whereas other components are individual for each product variant. This paper presents the problems that a company faces when trying to introduce a platform strategy and outlines a method to find suitable components to be made common. The method is shown with a simple case. The approach uses fuzzy logic to obtain a suitable criterion to assess the overall value of the product line and a genetic algorithm for finding the set of components to be made commo

Effects of Isolated Hip Abductor Fatigue on Frontal Plane Knee Mechanics

Purpose: Anterior cruciate ligament injuries and patellofemoral pain syndrome are both common and significant injuries to the knee that have been associated with hip weakness. Prospective studies have linked the risk of experiencing either injury to alterations in the frontal plane knee angle and moment during activity. These components of knee mechanics are theorized to be affected by hip abductor weakness. The purpose of this study was to identify the effects of isolated hip abductor fatigue-induced weakness on lower extremity kinematics and kinetics in recreationally active women

Introspective Pushdown Analysis of Higher-Order Programs

In the static analysis of functional programs, pushdown flow analysis and abstract garbage collection skirt just inside the boundaries of soundness and decidability. Alone, each method reduces analysis times and boosts precision by orders of magnitude. This work illuminates and conquers the theoretical challenges that stand in the way of combining the power of these techniques. The challenge in marrying these techniques is not subtle: computing the reachable control states of a pushdown system relies on limiting access during transition to the top of the stack; abstract garbage collection, on the other hand, needs full access to the entire stack to compute a root set, just as concrete collection does. \emph{Introspective} pushdown systems resolve this conflict. Introspective pushdown systems provide enough access to the stack to allow abstract garbage collection, but they remain restricted enough to compute control-state reachability, thereby enabling the sound and precise product of pushdown analysis and abstract garbage collection. Experiments reveal synergistic interplay between the techniques, and the fusion demonstrates "better-than-both-worlds" precision.Comment: Proceedings of the 17th ACM SIGPLAN International Conference on Functional Programming, 2012, AC